import sys
sys.path.append("d:\\老黄牛小工具\\脚本文件\\py")
import lilyfun  #老黄牛小工具下的文件

import json,time,base64


MOBAN="模板"
GENPATH="生成文件夹"
MBPATH=r'd:/老黄牛小工具/word模板'
PYTHONPATH=r'D:/老黄牛小工具/脚本文件/py'
JSONFILE=r'd:/老黄牛小工具/ExcelQuery/temp/temp.json'
JSONFILE2=r'd:/老黄牛小工具/ExcelQuery/temp/temp2.json'
TEMPTEXT=r'd:/老黄牛小工具/ExcelQuery/temp/temp.txt'
TEMPTDOCX=r'd:/老黄牛小工具/ExcelQuery/temp/temp.docx'

PYEXE="C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python37\\python.exe"
JBPATH=r'D:/老黄牛小工具/脚本文件'

#----------------1.初始化读取数据----------------------
arr={}
prstr="true" #是否打印输出
#----------------fastapi 的区域----------------------

from fastapi import FastAPI
from fastapi import FastAPI, File, UploadFile, Form
from fastapi import FastAPI, Request, Body
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
from fastapi import APIRouter,Depends,HTTPException,FastAPI,Request,Form,Body,File,UploadFile
from fastapi.templating import Jinja2Templates
from pydantic import BaseModel
from typing import Dict
from starlette.staticfiles import StaticFiles
import base64,random,asyncio,uvicorn,os
from starlette.responses import FileResponse
from pydantic import BaseModel
from typing import Union
import lilyfun,requests,json

import urllib.parse
from fastapi.middleware.cors import CORSMiddleware






app = FastAPI()

#设置允许访问的域名

#设置跨域传参
app.add_middleware(
    CORSMiddleware, 
    allow_origins=["*"],  #设置允许的origins来源
    allow_credentials=True,
    allow_methods=["*"],  # 设置允许跨域的http方法，比如 get、post、put等。
    allow_headers=["*"])  #允许跨域的headers，可以用来鉴别来源等作用。


class fd2(BaseModel):
    json64: Union[str, None] = None
    f64: Union[str, None] = None
    fkeyold: Union[str, None] = None
    fkeynew: Union[str, None] = None

class fd1(BaseModel):
    json64: str
    
#自动下载服务器上的脚本
@app.post("/dl/{jbname}")
async def dl(jbname:str):
    print(jbname)
    jbpath = lilyfun.getexepath(jbname)
    #print(jbpath)
    if jbpath=="JbNotExist":
        return jbpath
    else:
        ct2 = lilyfun.readtxt(jbpath)
    
        arr["ext"]=os.path.splitext(jbpath)[-1].replace('.',"")
        arr["f64"]=ct2
        json64=json.dumps(arr).encode("utf-8")
        return json64

#接收ahk上传过来的数据处理后返回
@app.post("/jb/{jbname}")  
async def jb(jbname: str,fd2:fd2):
    global prstr
    lilyfun.pr("--------------------------------------------------------------------------------",prstr)
    lilyfun.pr("----------------------   "   + time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) +"       " + jbname + "  ----------" ,prstr)
    lilyfun.pr("--------------------------------------------------------------------------------" ,prstr)
    json64,f64,fkeyold,fkeynew="","","",""
    # ----------------四、传入funinputarr并运行函数----------------------
    print(111111111)
    #导入py
    try:
        pyfun=jbname+"py"
        exec("import "+jbname+"py")
        #exec("import aaapy")
        
        lilyfun.pr("[main]导入文件 "+pyfun +" 成功！" ,prstr)
    except:
        lilyfun.pr("[main]导入文件 "+pyfun +" 出错了，文件不存在。" ,prstr)
        return  {"status":"error","json64":"","f64":""}

    #执行py,并返回值
    try:
        fd2new={}    
        fd2new=eval(pyfun).main(fd2)
    except:
        return  {"status":"error,exec ","json64":"","f64":""}

    
    try:
        json64=fd2new["json64"]
        f64=fd2new["f64"]
    except:
        f64=""
    return  {"status":"error,read json","json64":json64,"f64":f64}
        

    
    

    return  {"status":"success","json64":json64,"f64":f64}





#app=FastAPI()

#设置static文件夹与templates文件夹
templates=Jinja2Templates(directory="templates")
app.mount('/static', StaticFiles(directory='static'), name='static')







#构建前端传来的数据类型
class Item3(BaseModel):
    script_name:str  #脚本名称
    values:dict #输入
    database64:str

#接收数据
@app.post('/run4/')
def run4(item1:Item3):
    print("main 执行000000000000000000000000")
    fd2, arr = {}, {}
    #最终返回的字典
    result_={}
    #print("传入的值：")
    #print(item1)
    # 初始化，将前端的信息分离处理
    arr=item1.values
    #print(arr)
    jbname = item1.script_name

    lilyfun.titlepr("run4中的arr：",arr,"true")
    #如果有文件就输入base64编码，不然就等于""(空值)
    try:
        base64data=item1.database64.split(",")[1]
    except:
        base64data=item1.database64

    # 导包
    exec("import " + jbname)

    #获取脚本中的一些信息
    n = eval(jbname).fkeyold
    m = eval(jbname).fkeynew
    mv = eval(jbname).inarr

    #将fkeyold值导入
    try:
        arr[n] = eval(jbname).inarr[n]
    except:
        pass

    print("----------")
    print(arr)
    print("-----arr-----")
    # 将输入数据转化为json、base64形式
    fd2["json64"] = lilyfun.arr2json64str(arr)
    fd2["f64"] = base64data
    print("main 执行1")
    # 执行脚本文件
    fd2new = eval(jbname).main(fd2)
    print("main 执行结束")
    # 获取f64编码
    f64 = fd2new["f64"]

    #将文件名存入字典内
    result_["base64"]=f64

    #构造有文件的文件名，！！！可能有问题，这是只是inarr！！！
    try:
        result_["filename"]="file."+mv[m].split(".")[-1]
    except:
        result_["filename"]=""

    #将结果转化为json（解码）
    jsonarr = lilyfun.json64tojsonarr(fd2new["json64"])
    result=jsonarr["contents"]

    #将输出结果存入result_
    result_li = []
    for i in result.items():
        result_dic = {}
        result_dic["key"] = i[0]
        result_dic["values"] = i[1]
        result_li.append(result_dic)
    result_["state"]=result_li
    return result_




#进入首页
@app.get("/id")
async def root(request:Request):
    arr2,r={},{}
    #获取脚本文件
    script_file = os.listdir("./")
    # print(script_file)
    n=0
    li=[]
    t={}
    for i in script_file:     
        n=n+1
        if ".py" in i:
            t={}
            aa=i.split(".py")[0]
            #print(aa[len(aa)-2:len(aa)])
            if aa[len(aa)-2:len(aa)]=="py":
                t["功能名"]=aa[0:len(aa)-2]
            if t!={}:
                li.append(t)

    r["code"]=0
    r["info"]="正常返回json数据。"
    r["arr"]=li
    js=json.dumps(r,ensure_ascii=False)
    return js

#进入首页
@app.get("/")
async def root(request:Request):
    print("ddddd")
    return templates.TemplateResponse("index.html",{"request":request})


#@app.get('/')
#def id(request:Request,gn_type1:str):
#    return templates.TemplateResponse("index.html",{"request":request,"filelist":file_list.items()})

def gettodict(queryurl):
    b=str.split(queryurl,"&")
    arr={}
    for t in b:
        tt=str.split(t,"=")
        if len(tt)==2 and tt[0] != "":
            key=urllib.parse.unquote(tt[0])
            val=urllib.parse.unquote(tt[1])
            arr[key]=val
    return arr

#选择功能并进行相对应脚本的运行
@app.get('/jb/{gn_type1}')
def gn(request:Request,gn_type1:Union[str, None] = ""):
    #aa=parse_qs_bytes(request.url.query)
    getarr,postarr,newarr={},{},{}
    if os.path.exists(gn_type1 + ".py"):
       pyfun=gn_type1
    elif os.path.exists(gn_type1 + "py.py"):
       pyfun=gn_type1+"py"
    else:
       return "没有该脚本！"
    
    print(pyfun)
    exec("import " + pyfun)
    
    input1 = eval(pyfun).inarr
    fkeyold = eval(pyfun).fkeyold
    fkeynew = eval(pyfun).fkeynew
    
    print("jb get运行0")
    try: #怕执行出错
        try:
            exec("import " + pyfun)
            input1 = eval(pyfun).inarr
            fkeyold = eval(pyfun).fkeyold
            fkeynew = eval(pyfun).fkeynew
        except:
            print("导入函数出错，可能是引用了多线程函数的原因！~")
            return "导入函数出错，可能是引用了多线程函数的原因！~"

        print("jb get运行1")
        try:
            getarr=gettodict(request.url.query)
            print(getarr)
            if getarr!={}:
                postarr["script_name"]=pyfun  #脚本名称
                postarr["values"]=getarr
                postarr["database64"]=""
                #print(postarr)
                print("jb get运行2")
                url=str(request.base_url)+"run4/"
                html = requests.post(url, json.dumps(postarr),headers={"Content-Type": "application/json"})
                #print(html.text)
                print("jb get运行3")
                json1 = json.loads(html.text)

                try:
                    json1 = json.loads(html.text)
                    for arr in json1["state"]:
                        newarr[arr["key"]]=arr["values"]
                    return newarr
                except:
                    return json1

        except:
            return "传参后错误，请检查！"
        print("jb get运行4")

        #print(input2)
        input2=input1.copy()
        filename=""
        # 不需要输入文件

        # 需要输入文件
        if fkeyold!="" :
           if fkeyold in input2:
                input2.pop(fkeyold)
                filename=fkeyold
           #print(filename)
           #如果fkeynew非空的话，把输入时把他也删了。

        newkeyarr={}
        fval=""
        if fkeynew!="" :
            if fkeynew in input2:
                newkeyarr[fkeynew]=input2[fkeynew]
                fkey=newkeyarr[fkeynew]
                fval=input2[fkeynew]
                input2.pop(fkeynew)
        #lilyfun.titlepr("input2 ",input2，"true")
                
                

        print("jb get运行结束！~")
           # 返回结果
        return templates.TemplateResponse("gn4.html",
                                             {"request": request, "function": pyfun, "input_web": input2.items(),"filename":filename,"newfilearr": newkeyarr.items(),"fval":fval})
    
    except:
        return "执行出错了！"

#运行配置
if __name__ == '__main__':
    uvicorn.run("main:app",host="127.0.0.1",port=8001,reload=True,debug=True)
    # uvicorn main: app --host 127.0.0.1 --port 8001 --reload
